using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
using TesteIATcc.Entidades;
using TesteIATcc;

namespace TesteIATcc.Universo
{
    /// <summary>
    /// This is a game component that implements IUpdateable.
    /// </summary>
    public class Fase : Microsoft.Xna.Framework.GameComponent
    {
        #region atributos
        private Jogador jogador;
        private Fundo fundo01;
        private WaveInimigo wave1;
        private bool fimDaFase = false;
        #endregion

        #region propriedades
        public bool FimDaFase
        {
            get { return fimDaFase; }
            set { fimDaFase = value; }
        }
        #endregion

        #region construtor
        public Fase(TesteIA game, Jogador j)
            : base(game)
        {
            //this.jogador = j;

            this.fundo01 = new Fundo(game, "sprites\\fundoestrela");
            base.Game.Components.Add(this.fundo01);

            this.wave1 = new WaveInimigo(game, "sprites\\inimigo1", 5);
            base.Game.Components.Add(this.wave1);
        }
        #endregion

        #region metodos da interface
        /// <summary>
        /// Allows the game component to perform any initialization it needs to before starting
        /// to run.  This is where it can query for any required services and load content.
        /// </summary>
        public override void Initialize()
        {
            this.jogador = (Jogador)base.Game.Services.GetService(typeof(Jogador));
            base.Initialize();
        }

        /// <summary>
        /// Allows the game component to update itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        public override void Update(GameTime gameTime)
        {
            if (wave1.ondaAtiva)
            {
                for (int i = 0; i <= wave1.Inimigos.Count - 1; i++)
                {
                    //define area de colisao do jogador
                    Rectangle retJogador = new Rectangle(
                        this.jogador.SpriteJogador.PosicaoSprite.X,
                        this.jogador.SpriteJogador.PosicaoSprite.Y,
                        (int)this.jogador.SpriteJogador.TamanhoSprite.X,
                        (int)this.jogador.SpriteJogador.TamanhoSprite.Y
                        );
                    //define area de colisao do inimigo
                    Rectangle retInimigo = new Rectangle(
                        this.wave1.Inimigos[i].SpriteInimigo.PosicaoSprite.X,
                        this.wave1.Inimigos[i].SpriteInimigo.PosicaoSprite.Y,
                        (int)this.wave1.Inimigos[i].SpriteInimigo.TamanhoSprite.X,
                        (int)this.wave1.Inimigos[i].SpriteInimigo.TamanhoSprite.Y
                        );
                    //define area de colisao do tiro do inimigo
                    Rectangle retTiroInimigo = new Rectangle(
                        this.wave1.Inimigos[i].TiroInimigo.PosicaoSprite.X,
                        this.wave1.Inimigos[i].TiroInimigo.PosicaoSprite.Y,
                        (int)this.wave1.Inimigos[i].TiroInimigo.TamanhoSprite.X,
                        (int)this.wave1.Inimigos[i].TiroInimigo.TamanhoSprite.Y
                        );

                    //testa colisado do jogador com o inimigo
                    if ((this.wave1.Inimigos[i].SpriteInimigo.Visible) && (this.jogador.SpriteJogador.Visible))
                    {
                        if (retInimigo.Intersects(retJogador))
                        {
                            this.jogador.SpriteJogador.Visible = false;
                            this.wave1.Inimigos[i].SpriteInimigo.Visible = false;
                        }
                    }

                    //testa colisao do tiro do inimigo com o jogador
                    if ((this.jogador.SpriteJogador.Visible) && (this.wave1.Inimigos[i].TiroInimigo.Visible))
                    {
                        if (retTiroInimigo.Intersects(retJogador))
                        {
                            this.jogador.SpriteJogador.Visible = false;
                            this.wave1.Inimigos[i].TiroInimigo.Visible = false;
                            this.wave1.Inimigos[i].reposicionaTiroNave();
                        }
                    }

                    //testa colisao do tiro jogador com o inimigo
                    for (int j = 0; j <= this.jogador.TiroJogador.Count - 1; j++)
                    {
                        Rectangle retTiroJogador = new Rectangle(
                            this.jogador.TiroJogador[j].PosicaoSprite.X,
                            this.jogador.TiroJogador[j].PosicaoSprite.Y,
                            (int)this.jogador.TiroJogador[j].TamanhoSprite.X,
                            (int)this.jogador.TiroJogador[j].TamanhoSprite.Y
                            );

                        if ((this.jogador.TiroJogador[j].Visible) && (this.wave1.Inimigos[i].SpriteInimigo.Visible))
                        {
                            if (retTiroJogador.Intersects(retInimigo))
                            {
                                this.jogador.TiroJogador[j].Visible = false;
                                this.jogador.ReposicionaTiroInvisivel();
                                this.wave1.Inimigos[i].SpriteInimigo.Visible = false;
                            }
                        }
                    }

                    //testa colisao do tiro do ajudante com o inimigo
                    for (int k = 0; k <= this.jogador.Ajudante01.TiroAjudante.Count -1; k++)
                    {
                        Rectangle retTiroAjudante = new Rectangle(
                            this.jogador.Ajudante01.TiroAjudante[k].PosicaoSprite.X,
                            this.jogador.Ajudante01.TiroAjudante[k].PosicaoSprite.Y,
                            (int)this.jogador.Ajudante01.TiroAjudante[k].TamanhoSprite.X,
                            (int)this.jogador.Ajudante01.TiroAjudante[k].TamanhoSprite.Y
                            );

                        if ((this.jogador.Ajudante01.TiroAjudante[k].Visible) && (this.wave1.Inimigos[i].SpriteInimigo.Visible))
                        {
                            if (retTiroAjudante.Intersects(retInimigo))
                            {
                                this.jogador.Ajudante01.TiroAjudante[k].Visible = false;
                                this.jogador.Ajudante01.ReposicionaTiroInvisivel();
                                this.wave1.Inimigos[i].SpriteInimigo.Visible = false;
                            }
                        }
                    }
                }
            }

            base.Update(gameTime);
        }
        #endregion
    }
}